package ihm.controller;

import com.icesoft.faces.component.panelpositioned.PanelPositionedEvent;
import dao.FeedbackFacadeLocal;
import dao.QuestionnaireFacadeLocal;
import dao.TypeQuestionnaireFacadeLocal;
import entite.EtatEnum;
import entite.Questionnaire;
import entite.QuestionnaireQuestion;
import entite.TypeQuestionnaire;
import ihm.util.AidePagination;
import ihm.util.Util;
import ihm.util.XMLTools;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Serializable;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import javax.faces.model.SelectItem;
import metier.GestionQuestionnaireLocal;

@ManagedBean(name = "questionnaireController")
@ViewScoped
public class QuestionnaireController implements Serializable {

    /**
     * Page de navigation,
     * la page par défaut est la page de liste la liste des questionnaires.
     */
    private String page = "listeQuestionnaires";
    /**
     * Le questionnaire courant.
     */
    private Questionnaire questionnaire;
    private DataModel questionnaires = null;
    /**
     * Liste des questionnaires ouverts.
     */
    private DataModel questionnairesOuverts = null;
    /**
     * Enumération des états de questionnaire possible sous forme de tableau pour l'affichage.
     */
    private EtatEnum[] listeEtat = EtatEnum.values();
    /**
     * Etat précédent pour la navigation dans le menu de gauche.
     */
    private EtatEnum filtreEtatPrecedent = EtatEnum.EN_CREATION;
    /**
     * Etat courant pour la naviation dans le menu de gauche.
     */
    private EtatEnum filtreEtatCourant = EtatEnum.DIFFUSER;
    /**
     * Pour rechercher les données en base.
     */
    @EJB
    private QuestionnaireFacadeLocal questionnaireFacade;
    /**
     * Pour rechercher les données en base.
     */
    @EJB
    private TypeQuestionnaireFacadeLocal typeQuestionnaireFacade;
    /**
     * EJB métier
     */
    @EJB
    private GestionQuestionnaireLocal gestionQuestionnaire;

    @EJB
    private FeedbackFacadeLocal FeedbackFacade;

    /**
     * ManagedBean de niveau session qui contient l'utilisateur connecté.
     */
    @ManagedProperty(value = "#{sessionController}")
    private SessionController sessionController;
    @ManagedProperty(value = "#{clientController}")
    private ClientController clientController;
    private AidePagination pagination;
    private List utilisateursSelected;

    /**
     * Page de navigation
     * @return le nom de la page à afficher
     */
    public String getPage() {
        return page;
    }

    /**
     * Page de navigation
     * @param page
     */
    public void setPage(String page) {
        this.page = page;
    }

    /**
     * Getter QuestionnaireOuvert avec pagination
     * @return dataModel
     */
    public DataModel getQuestionnairesOuverts() {
        if (questionnairesOuverts == null) {
            questionnairesOuverts = getPagination().createPageDataModelOuvert();
        }
        return questionnairesOuverts;
    }

    /**
     * Setter QuestionnaireOuverts
     * @param questionnairesOuverts
     */
    public void setQuestionnairesOuverts(DataModel questionnairesOuverts) {
        this.questionnairesOuverts = questionnairesOuverts;
    }

    /**
     * Setter sessionController
     * @param sessionController
     */
    public void setSessionController(SessionController sessionController) {
        this.sessionController = sessionController;
    }
    private QuestionnaireQuestion questionSuppr;

    /**
     * Setter QuestionSuppr
     * @param questionSuppr
     */
    public void setQuestionSuppr(QuestionnaireQuestion questionSuppr) {
        this.questionSuppr = questionSuppr;
    }

    /**
     * Getter QuestionSuppr
     * @return QuestionnaireQuestion
     */
    public QuestionnaireQuestion getQuestionSuppr() {
        return questionSuppr;
    }

    /**
     * Constructeur
     */
    public QuestionnaireController() {
    }

    /**
     * Getter Questionnaire
     * @return Questionnaire
     */
    public Questionnaire getQuestionnaire() {
        if (questionnaire == null) {
            questionnaire = new Questionnaire();
        }
        return questionnaire;
    }

    /**
     * Setter Questionnaire
     * @param questionnaire
     */
    public void setQuestionnaire(Questionnaire questionnaire) {
        System.out.println("setQuestionnaire : " + questionnaire);
        this.questionnaire = questionnaire;
    }

    /**
     * Getter FiltreEtatCourant
     * @return EtatEnum
     */
    public EtatEnum getFiltreEtatCourant() {
        return filtreEtatCourant;
    }

    /**
     * Setter FiltreEtatCourant
     * @param filtreEtat
     */
    public void setFiltreEtatCourant(EtatEnum filtreEtat) {
        this.filtreEtatCourant = filtreEtat;
    }

    /**
     * Getter TypeQuestionnaire
     * @param idTypeQuestionnaire
     * @return TypeQuestionnaire
     */
    public TypeQuestionnaire getTypeQuestionnaire(Integer idTypeQuestionnaire) {
        return typeQuestionnaireFacade.find(idTypeQuestionnaire);
    }

    /**
     * Getter TypeQuestionnaireSelectItems
     * @return SelectItem[] des types de questionnaire
     */
    public SelectItem[] getTypeQuestionnaireSelectItems() {
        List<TypeQuestionnaire> typeQuestionnaires = typeQuestionnaireFacade.findAll();
        SelectItem[] items = new SelectItem[typeQuestionnaires.size()];
        int i = 0;
        for (TypeQuestionnaire tq : typeQuestionnaires) {
            items[i++] = new SelectItem(tq, tq.getLibelle());
        }
        return items;
    }

    /**
     * Méthode d'enregistrement des questionnaires
     * @return null
     */
    public String enregistrerQuestionnaire() {
        if (questionnaire.getEtatQuestionnaireCourant() == null) {
            gestionQuestionnaire.enregistrerNouveauQuestionnaire(questionnaire,
                    sessionController.getUtilisateur());
            Util.addInfoMessage(null, "QuestionnaireCreer", FacesContext.getCurrentInstance());
        } else {
            gestionQuestionnaire.modifierQuestionnaire(questionnaire,
                    sessionController.getUtilisateur(), questionnaire.getEtatQuestionnaireCourant());
            Util.addInfoMessage(null, "QuestionnaireModifier", FacesContext.getCurrentInstance());
        }

        return null;
    }

    /**
     * Méthode de validation des questionnaires
     * @return
     */
    public String validerQuestionnaire() {
        if (questionnaire == null) {
            Util.addErrorMessage(null, "QuestionnaireVide", FacesContext.getCurrentInstance());
            return null;
        }
        if (questionnaire.getQuestionnaireQuestionCollection() == null
                || questionnaire.getQuestionnaireQuestionCollection().isEmpty()) {
            Util.addErrorMessage(null, "QuestionnaireQuestionsVide", FacesContext.getCurrentInstance());
            return null;
        }

        if (!questionnaire.getDateCloturer().after(questionnaire.getDateOuverture())) {
            Util.addErrorMessage(null, "DateClotureAvantOuverture", FacesContext.getCurrentInstance());
            return null;
        }
        gestionQuestionnaire.modifierQuestionnaire(questionnaire,
                sessionController.getUtilisateur(), EtatEnum.VALIDER);
        Util.addInfoMessage(null, "QuestionnaireValiderOk", FacesContext.getCurrentInstance());

        page = "listeQuestionnaires";
        filtreEtatCourant = questionnaire.getEtatQuestionnaireCourant();
        return null;
    }

    /**
     * Méthode d'invalidation des questionnaires
     * @return
     */
    public String invaliderQuestionnaire() {
        if (questionnaire == null) {
            Util.addErrorMessage(null, "QuestionnaireVide", FacesContext.getCurrentInstance());
            return null;
        }
        gestionQuestionnaire.modifierQuestionnaire(questionnaire,
                sessionController.getUtilisateur(), EtatEnum.EN_CREATION);
        page = "listeQuestionnaires";
        filtreEtatCourant = questionnaire.getEtatQuestionnaireCourant();
        // recreateModel();
        return null;
    }

    /**
     *
     * @return
     */
    public String ajouterQuestion() {


        return null;
    }

    /**
     *
     * @return
     */
    public DataModel getQuestionnaires() {
        if (questionnaires == null || !filtreEtatPrecedent.equals(filtreEtatCourant)) {
            questionnaires = getPagination().createPageDataModel();
            filtreEtatPrecedent = filtreEtatCourant;
        }
        return questionnaires;
    }

    /**
     *
     * @return
     */
    public EtatEnum[] getListeEtat() {
        return listeEtat;
    }

    /**
     *
     * @return
     */
    public String suppr() {

        questionnaire.getQuestionnaireQuestionCollection().remove(questionSuppr);
        questionnaireFacade.edit(questionnaire);
        return null;
    }

    /**
     *
     * @return
     */
    public AidePagination getPagination() {
        if (pagination == null) {
            pagination = new AidePagination(10) {

                @Override
                public int getItemsCount() {
                    //prepareList();
                    return questionnaireFacade.findAll(filtreEtatCourant).size();
                }

                @Override
                public DataModel createPageDataModel() {
                    //prepareList();
                    return new ListDataModel(questionnaireFacade.findRange(new int[]{getPageFirstItem(), getPageFirstItem() + getPageSize()}, filtreEtatCourant));
                }

                @Override
                public int getItemsCountOuvert() {
                    //prepareList();
                    return questionnaireFacade.findOuvert(EtatEnum.DIFFUSER).size();
                }

                @Override
                public DataModel createPageDataModelOuvert() {
                    //prepareList();
                    return new ListDataModel(questionnaireFacade.findRangeOuvert(new int[]{getPageFirstItem(), getPageFirstItem() + getPageSize()}, EtatEnum.DIFFUSER));
                }
            };
        }
        return pagination;
    }

    /**
     *
     * @return
     */
    public String prepareList() {
        recreateModel();
        return null;
    }

    private void recreateModel() {
        clientController.setPage("questionnairesOuverts");
        questionnairesOuverts = null;

        questionnaires = null;
    }

    /**
     *
     * @return
     */
    public String next() {
        getPagination().nextPage();
        recreateModel();
        return null;
    }

    /**
     *
     * @return
     */
    public String previous() {
        getPagination().previousPage();
        recreateModel();
        return null;
    }

    /**
     *
     * @return
     */
    public String refresh() {
        questionnaires = null;
        return null;
    }

    /**
     *
     * @return
     */
    public String nouveau() {
        questionnaire = null;
        return null;
    }

    /**
     *
     * @param evt
     */
    public void changerOrdreQuestions(PanelPositionedEvent evt) {
        if (evt.getOldIndex() != -1) {
            int i = 0;
            for (QuestionnaireQuestion qq : questionnaire.getQuestionnaireQuestionCollection()) {
                qq.setOrdre(i++);
            }

        }
        questionnaire = questionnaireFacade.edit(questionnaire);
    }

    /**
     *
     * @return
     */
    public String supprimer() {
        gestionQuestionnaire.modifierQuestionnaire(questionnaire,
                sessionController.getUtilisateur(), EtatEnum.SUPPRIMER);
        recreateModel();
        return null;
    }

    public String effacer() {
        if (FeedbackFacade.find(questionnaire).isEmpty()) {
             questionnaireFacade.remove(questionnaire);
               recreateModel();
        } else {
            Util.addErrorMessage(null, "effacerQuestionnaireImposible", FacesContext.getCurrentInstance());
        }
       
      
        return null;
    }

    public String bloquer() {
        gestionQuestionnaire.modifierQuestionnaire(questionnaire,
                sessionController.getUtilisateur(), EtatEnum.BLOQUER);
        recreateModel();
        return null;
    }

    public String debloquer() {
        gestionQuestionnaire.modifierQuestionnaire(questionnaire,
                sessionController.getUtilisateur(), EtatEnum.DIFFUSER);
        recreateModel();
        return null;
    }

    public String cloturer() {
        gestionQuestionnaire.modifierQuestionnaire(questionnaire,
                sessionController.getUtilisateur(), EtatEnum.CLOTURER);
        recreateModel();
        return null;
    }

    public String exporter(){
        try {
            XMLTools.encodeToFile(questionnaire);
        } catch (FileNotFoundException ex) {
            Logger.getLogger(QuestionnaireController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(QuestionnaireController.class.getName()).log(Level.SEVERE, null, ex);
        }
         recreateModel();
        return null;
    }
    /**
     *
     * @return
     */
    public List getUtilisateursSelected() {
        return utilisateursSelected;
    }

    /**
     *
     * @param utilisateursSelected
     */
    public void setUtilisateursSelected(List utilisateursSelected) {
        this.utilisateursSelected = utilisateursSelected;
    }

    public void setClientController(ClientController clientController) {
        this.clientController = clientController;
    }
}
